home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Python 1.4 / Python 1.4 source / Modules / nismodule.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-26  |  6.4 KB  |  345 lines  |  [TEXT/CWIE]
  1. /***********************************************************
  2.     Written by:
  3.     Fred Gansevles <Fred.Gansevles@cs.utwente.nl>
  4.     Vakgroep Spa,
  5.     Faculteit der Informatica,
  6.     Universiteit Twente,
  7.     Enschede,
  8.     the Netherlands.
  9. ******************************************************************/
  10.  
  11. /* NIS module implementation */
  12.  
  13. #include "allobjects.h"
  14. #include "modsupport.h"
  15. #include "ceval.h"
  16.  
  17. #include <sys/time.h>
  18. #include <sys/types.h>
  19. #include <rpc/rpc.h>
  20. #include <rpcsvc/yp_prot.h>
  21. #include <rpcsvc/ypclnt.h>
  22.  
  23. static object *NisError;
  24.  
  25. static object *
  26. nis_error (err)
  27.     int err;
  28. {
  29.     err_setstr(NisError, yperr_string(err));
  30.     return NULL;
  31. }
  32.  
  33. static struct nis_map {
  34.     char *alias;
  35.     char *map;
  36. } aliases [] = {
  37.     {"passwd",    "passwd.byname"},
  38.     {"group",    "group.byname"},
  39.     {"networks",    "networks.byaddr"},
  40.     {"hosts",    "hosts.byname"},
  41.     {"protocols",    "protocols.bynumber"},
  42.     {"services",    "services.byname"},
  43.     {"aliases",    "mail.aliases"},
  44.     {"ethers",    "ethers.byname"},
  45.     {0L,        0L}
  46. };
  47.  
  48. static char *
  49. nis_mapname (map)
  50.     char *map;
  51. {
  52.     int i;
  53.  
  54.     for (i=0; aliases[i].alias != 0L; i++)
  55.         if (!strcmp (aliases[i].alias, map))
  56.             map = aliases[i].map;
  57.     return map;
  58. }
  59.  
  60. typedef int (*foreachfunc) PROTO((int, char *, int, char *, int, char *));
  61.  
  62. static int
  63. nis_foreach (instatus, inkey, inkeylen, inval, invallen, indata)
  64.     int instatus;
  65.     char *inkey;
  66.     int inkeylen;
  67.     char *inval;
  68.     int invallen;
  69.     object *indata;
  70. {
  71.     if (instatus == YP_TRUE) {
  72.         object *key = newsizedstringobject(inkey, inkeylen);
  73.         object *val = newsizedstringobject(inval, invallen);
  74.         int err;
  75.         if (key == NULL || val == NULL) {
  76.             /* XXX error -- don't know how to handle */
  77.             err_clear();
  78.             XDECREF(key);
  79.             XDECREF(val);
  80.             return 1;
  81.         }
  82.         err = mappinginsert(indata, key, val);
  83.         DECREF(key);
  84.         DECREF(val);
  85.         if (err != 0) {
  86.             err_clear();
  87.             return 1;
  88.         }
  89.         return 0;
  90.     }
  91.     return 1;
  92. }
  93.  
  94. static object *
  95. nis_match (self, args)
  96.     object *self;
  97.     object *args;
  98. {
  99.     char *match;
  100.     char *domain;
  101.     int keylen, len;
  102.     char *key, *map;
  103.     int err;
  104.     object *res;
  105.  
  106.     if (!getargs(args, "(s#s)", &key, &keylen, &map))
  107.         return NULL;
  108.     if ((err = yp_get_default_domain(&domain)) != 0)
  109.         return nis_error(err);
  110.     BGN_SAVE
  111.     map = nis_mapname (map);
  112.     err = yp_match (domain, map, key, keylen, &match, &len);
  113.     END_SAVE
  114.     if (err != 0)
  115.         return nis_error(err);
  116.     res = newsizedstringobject (match, len);
  117.     free (match);
  118.     return res;
  119. }
  120.  
  121. static object *
  122. nis_cat (self, args)
  123.     object *self;
  124.     object *args;
  125. {
  126.     char *domain;
  127.     char *map;
  128.     struct ypall_callback cb;
  129.     object *cat;
  130.     int err;
  131.  
  132.     if (!getstrarg(args, &map))
  133.         return NULL;
  134.     if ((err = yp_get_default_domain(&domain)) != 0)
  135.         return nis_error(err);
  136.     cat = newdictobject ();
  137.     if (cat == NULL)
  138.         return NULL;
  139.     cb.foreach = (foreachfunc)nis_foreach;
  140.     cb.data = (char *)cat;
  141.     BGN_SAVE
  142.     map = nis_mapname (map);
  143.     err = yp_all (domain, map, &cb);
  144.     END_SAVE
  145.     if (err != 0) {
  146.         DECREF(cat);
  147.         return nis_error(err);
  148.     }
  149.     return cat;
  150. }
  151.  
  152. /* These should be u_long on Sun h/w but not on 64-bit h/w.
  153.    This is not portable to machines with 16-bit ints and no prototypes */
  154. #ifndef YPPROC_MAPLIST
  155. #define YPPROC_MAPLIST    11
  156. #endif
  157. #ifndef YPPROG
  158. #define YPPROG        100004
  159. #endif
  160. #ifndef YPVERS
  161. #define YPVERS        2
  162. #endif
  163.  
  164. typedef char *domainname;
  165. typedef char *mapname;
  166.  
  167. enum nisstat {
  168.     NIS_TRUE = 1,
  169.     NIS_NOMORE = 2,
  170.     NIS_FALSE = 0,
  171.     NIS_NOMAP = -1,
  172.     NIS_NODOM = -2,
  173.     NIS_NOKEY = -3,
  174.     NIS_BADOP = -4,
  175.     NIS_BADDB = -5,
  176.     NIS_YPERR = -6,
  177.     NIS_BADARGS = -7,
  178.     NIS_VERS = -8
  179. };
  180. typedef enum nisstat nisstat;
  181.  
  182. struct nismaplist {
  183.     mapname map;
  184.     struct nismaplist *next;
  185. };
  186. typedef struct nismaplist nismaplist;
  187.  
  188. struct nisresp_maplist {
  189.     nisstat stat;
  190.     nismaplist *maps;
  191. };
  192. typedef struct nisresp_maplist nisresp_maplist;
  193.  
  194. static struct timeval TIMEOUT = { 25, 0 };
  195.  
  196. static
  197. bool_t
  198. nis_xdr_domainname(xdrs, objp)
  199.     XDR *xdrs;
  200.     domainname *objp;
  201. {
  202.     if (!xdr_string(xdrs, objp, YPMAXDOMAIN)) {
  203.         return (FALSE);
  204.     }
  205.     return (TRUE);
  206. }
  207.  
  208. static
  209. bool_t
  210. nis_xdr_mapname(xdrs, objp)
  211.     XDR *xdrs;
  212.     mapname *objp;
  213. {
  214.     if (!xdr_string(xdrs, objp, YPMAXMAP)) {
  215.         return (FALSE);
  216.     }
  217.     return (TRUE);
  218. }
  219.  
  220. static
  221. bool_t
  222. nis_xdr_ypmaplist(xdrs, objp)
  223.     XDR *xdrs;
  224.     nismaplist *objp;
  225. {
  226.     if (!nis_xdr_mapname(xdrs, &objp->map)) {
  227.         return (FALSE);
  228.     }
  229.     if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof(nismaplist), nis_xdr_ypmaplist)) {
  230.         return (FALSE);
  231.     }
  232.     return (TRUE);
  233. }
  234.  
  235. static
  236. bool_t
  237. nis_xdr_ypstat(xdrs, objp)
  238.     XDR *xdrs;
  239.     nisstat *objp;
  240. {
  241.     if (!xdr_enum(xdrs, (enum_t *)objp)) {
  242.         return (FALSE);
  243.     }
  244.     return (TRUE);
  245. }
  246.  
  247.  
  248. static
  249. bool_t
  250. nis_xdr_ypresp_maplist(xdrs, objp)
  251.     XDR *xdrs;
  252.     nisresp_maplist *objp;
  253. {
  254.     if (!nis_xdr_ypstat(xdrs, &objp->stat)) {
  255.         return (FALSE);
  256.     }
  257.     if (!xdr_pointer(xdrs, (char **)&objp->maps, sizeof(nismaplist), nis_xdr_ypmaplist)) {
  258.         return (FALSE);
  259.     }
  260.     return (TRUE);
  261. }
  262.  
  263.  
  264. static
  265. nisresp_maplist *
  266. nisproc_maplist_2(argp, clnt)
  267.     domainname *argp;
  268.     CLIENT *clnt;
  269. {
  270.     static nisresp_maplist res;
  271.  
  272.     memset(&res, 0, sizeof(res));
  273.     if (clnt_call(clnt, YPPROC_MAPLIST, nis_xdr_domainname, (caddr_t)argp,
  274.           nis_xdr_ypresp_maplist, (caddr_t)&res, TIMEOUT)
  275.     != RPC_SUCCESS) {
  276.         return (NULL);
  277.     }
  278.     return (&res);
  279. }
  280.  
  281. static
  282. nismaplist *
  283. nis_maplist ()
  284. {
  285.     nisresp_maplist *list;
  286.     char *dom;
  287.     CLIENT *cl, *clnt_create();
  288.     char *server;
  289.  
  290.     yp_get_default_domain (&dom);
  291.     yp_master (dom, aliases[0].map, &server);
  292.     cl = clnt_create(server, YPPROG, YPVERS, "tcp");
  293.     if (cl == NULL) {
  294.         clnt_pcreateerror(server);
  295.         return NULL;
  296.     }
  297.     list = nisproc_maplist_2 (&dom, cl);
  298.     if (list == NULL)
  299.         return NULL;
  300.     if (list->stat != NIS_TRUE)
  301.         return NULL;
  302.     return list->maps;
  303. }
  304.  
  305. static object *
  306. nis_maps (self, args)
  307.     object *self;
  308.     object *args;
  309. {
  310.     nismaplist *maps;
  311.     object *list;
  312.  
  313.     if ((maps = nis_maplist ()) == NULL)
  314.         return NULL;
  315.     if ((list = newlistobject(0)) == NULL)
  316.         return NULL;
  317.     for (maps = maps->next; maps; maps = maps->next) {
  318.         if (addlistitem (list, newstringobject (maps->map)) < 0) {
  319.             DECREF(list);
  320.             list = NULL;
  321.             break;
  322.         }
  323.     }
  324.     /* XXX Shouldn't we free the list of maps now? */
  325.     return list;
  326. }
  327.  
  328. static struct methodlist nis_methods[] = {
  329.     {"match",    nis_match},
  330.     {"cat",        nis_cat},
  331.     {"maps",    nis_maps},
  332.     {NULL,        NULL}         /* Sentinel */
  333. };
  334.  
  335. void
  336. initnis ()
  337. {
  338.     object *m, *d;
  339.     m = initmodule("nis", nis_methods);
  340.     d = getmoduledict(m);
  341.     NisError = newstringobject("nis.error");
  342.     if (NisError == NULL || dictinsert(d, "error", NisError) != 0)
  343.         fatal("Cannot define nis.error");
  344. }
  345.